import { ref } from 'vue'
import { invoke } from '@tauri-apps/api/core'
import { message } from 'ant-design-vue'

/**
 * 订单验证 Composable
 * 提供订单提交前的完整验证功能，包括：
 * - 合约代码验证
 * - 价格最小变动价位验证
 * - 委托手数限制验证
 * - 资金充足性验证
 * - 持仓可平性验证
 * - 市场状态验证
 */
export function useOrderValidation() {
  const isValidating = ref(false)
  const lastValidationResult = ref(null)
  const validationErrors = ref([])

  /**
   * 验证订单
   * @param {Object} order - 订单对象
   * @param {string} order.instrument_id - 合约代码
   * @param {string} order.direction - 方向 ("0"=买入, "1"=卖出)
   * @param {number} order.price - 价格
   * @param {number} order.volume - 手数
   * @param {string} order.order_type - 订单类型
   * @param {string} order.offset_flag - 开平标志 ("0"=开仓, "1"=平仓)
   * @param {Object} windowContext - 窗口上下文信息
   * @returns {Promise<{isValid: boolean, errors: Array}>}
   */
  const validateOrder = async (order, windowContext = null) => {
    isValidating.value = true
    validationErrors.value = []
    
    try {
      console.log('🔍 [VALIDATION] 开始验证订单:', order)
      
      // 获取当前活跃的trader session
      const sessionResult = await invoke('get_active_trader_session')
      if (!sessionResult.success) {
        const error = {
          error_type: 'NO_SESSION',
          message: '未找到活跃的交易会话，请先登录',
          field: null,
          play_sound: true
        }
        validationErrors.value = [error]
        showValidationError(error)
        return { isValid: false, errors: [error] }
      }

      const sessionId = sessionResult.data
      
      // 调用后端验证接口
      const result = await invoke('validate_order_request', {
        sessionId,
        order,
        windowContext
      })
      
      lastValidationResult.value = result
      validationErrors.value = result.errors || []
      
      if (!result.is_valid) {
        console.error('❌ [VALIDATION] 订单验证失败:', result.errors)
        
        // 显示所有验证错误
        result.errors.forEach(error => {
          showValidationError(error)
        })
        
        return { isValid: false, errors: result.errors }
      }
      
      console.log('✅ [VALIDATION] 订单验证通过')
      return { isValid: true, errors: [] }
      
    } catch (error) {
      console.error('❌ [VALIDATION] 验证过程发生错误:', error)
      
      const validationError = {
        error_type: 'VALIDATION_ERROR',
        message: `验证失败: ${error.message || error}`,
        field: null,
        play_sound: true
      }
      
      validationErrors.value = [validationError]
      showValidationError(validationError)
      
      return { isValid: false, errors: [validationError] }
      
    } finally {
      isValidating.value = false
    }
  }

  /**
   * 显示验证错误消息
   * @param {Object} error - 错误对象
   */
  const showValidationError = (error) => {
    const errorTypeMap = {
      'INVALID_INSTRUMENT': '❌ 合约无效',
      'INSTRUMENT_NOT_TRADING': '⏸️ 合约不可交易',
      'INSTRUMENT_NOT_FOUND': '🔍 合约未找到',
      'INVALID_PRICE_TICK': '📏 价格间距错误',
      'VOLUME_TOO_SMALL': '📉 手数过小',
      'VOLUME_TOO_LARGE': '📈 手数过大',
      'INSUFFICIENT_FUNDS': '💰 资金不足',
      'NO_POSITION_TO_CLOSE': '📊 无持仓可平',
      'INSUFFICIENT_POSITION': '📊 持仓不足',
      'MARKET_CLOSED': '🔒 市场关闭',
      'INSTRUMENT_EXPIRED': '⏰ 合约过期',
      'NO_SESSION': '🔐 未登录',
      'VALIDATION_ERROR': '⚠️ 验证错误'
    }

    const title = errorTypeMap[error.error_type] || '⚠️ 验证错误'
    
    message.error({
      content: `${title}: ${error.message}`,
      duration: 5,
      style: {
        marginTop: '10vh',
        fontSize: '14px'
      }
    })
  }

  /**
   * 快速验证 - 只验证基本字段，不调用后端
   * @param {Object} order - 订单对象
   * @returns {Object} {isValid: boolean, errors: Array}
   */
  const quickValidate = (order) => {
    const errors = []

    // 验证合约代码
    if (!order.instrument_id || order.instrument_id.trim() === '') {
      errors.push({
        error_type: 'INVALID_INSTRUMENT',
        message: '合约代码不能为空',
        field: 'instrument_id',
        play_sound: false
      })
    }

    // 验证价格
    if (order.price <= 0) {
      errors.push({
        error_type: 'INVALID_PRICE',
        message: '价格必须大于0',
        field: 'price',
        play_sound: false
      })
    }

    // 验证手数
    if (order.volume <= 0) {
      errors.push({
        error_type: 'INVALID_VOLUME',
        message: '手数必须大于0',
        field: 'volume',
        play_sound: false
      })
    }

    // 验证方向
    if (order.direction !== '0' && order.direction !== '1') {
      errors.push({
        error_type: 'INVALID_DIRECTION',
        message: '交易方向无效',
        field: 'direction',
        play_sound: false
      })
    }

    return {
      isValid: errors.length === 0,
      errors
    }
  }

  /**
   * 获取错误类型的友好描述
   * @param {string} errorType - 错误类型
   * @returns {string} 友好描述
   */
  const getErrorDescription = (errorType) => {
    const descriptions = {
      'INVALID_INSTRUMENT': '合约代码无效或不存在',
      'INSTRUMENT_NOT_TRADING': '合约当前不在交易时段',
      'INSTRUMENT_NOT_FOUND': '未找到该合约信息，请先查询合约列表',
      'INVALID_PRICE_TICK': '价格不符合最小变动价位要求',
      'VOLUME_TOO_SMALL': '委托手数小于最小限制',
      'VOLUME_TOO_LARGE': '委托手数超过单笔最大限制',
      'INSUFFICIENT_FUNDS': '账户可用资金不足以开仓',
      'NO_POSITION_TO_CLOSE': '没有对应的持仓可以平仓',
      'INSUFFICIENT_POSITION': '可平持仓数量不足',
      'MARKET_CLOSED': '市场当前不在交易时段',
      'INSTRUMENT_EXPIRED': '合约已过期或即将到期',
      'NO_SESSION': '未找到活跃的交易会话',
      'VALIDATION_ERROR': '订单验证过程发生错误'
    }
    return descriptions[errorType] || '未知错误'
  }

  /**
   * 清除验证结果
   */
  const clearValidation = () => {
    lastValidationResult.value = null
    validationErrors.value = []
  }

  /**
   * 获取特定字段的错误
   * @param {string} field - 字段名
   * @returns {Array} 该字段的所有错误
   */
  const getFieldErrors = (field) => {
    return validationErrors.value.filter(error => error.field === field)
  }

  /**
   * 检查特定字段是否有错误
   * @param {string} field - 字段名
   * @returns {boolean} 是否有错误
   */
  const hasFieldError = (field) => {
    return getFieldErrors(field).length > 0
  }

  return {
    // 状态
    isValidating,
    lastValidationResult,
    validationErrors,
    
    // 方法
    validateOrder,
    quickValidate,
    clearValidation,
    getErrorDescription,
    getFieldErrors,
    hasFieldError,
    showValidationError
  }
}
